const gaiaManager = require('../../utils/gaiaManager.js').gaiaManager
const bluetoothManager = require('../../utils/bluetooth.js').bluetoothManager

Page({
  data: {
    // 页面状态
    loading: true,
    error: null,
    ancChanging: false, // ANC状态改变中，防止重复点击
    
    // 音频管理设置项（与安卓版本AudioCurationSettings.kt保持一致）
    settings: {
      // ANC状态
      ancState: {
        visible: true,
        enabled: false,
        title: 'Active noise cancellation',
        description: '启用或禁用主动降噪功能'
      },
      
      // 切换行为配置
      toggleConfiguration: {
        visible: true,
        title: 'Toggle behaviour',
        items: [
          {
            key: 'toggle_1',
            title: 'Toggle 1',
            value: null,
            description: '配置切换1的行为'
          },
          {
            key: 'toggle_2', 
            title: 'Toggle 2',
            value: null,
            description: '配置切换2的行为'
          },
          {
            key: 'toggle_3',
            title: 'Toggle 3', 
            value: null,
            description: '配置切换3的行为'
          }
        ]
      },
      
      // 其他行为配置
      otherConfigurations: {
        visible: true,
        title: 'Other behaviours',
        items: [
          {
            key: 'idle_configuration',
            title: 'During idle',
            value: null,
            description: '配置空闲时的行为'
          },
          {
            key: 'playback_configuration',
            title: 'During playback',
            value: null,
            description: '配置播放时的行为'
          },
          {
            key: 'calls_configuration',
            title: 'During calls',
            value: null,
            description: '配置通话时的行为'
          },
          {
            key: 'assistant_configuration',
            title: 'During assistant',
            value: null,
            description: '配置助手时的行为'
          },
          {
            key: 'voice_recording_configuration',
            title: 'During voice recording',
            value: null,
            description: '配置语音录制时的行为',
            visible: false // 默认隐藏，根据设备支持情况显示
          }
        ]
      },
      
      // 自动透明度
      autoTransparency: {
        visible: false, // 默认隐藏，根据设备支持情况显示
        title: 'Auto-transparency',
        state: {
          visible: true,
          enabled: false,
          title: 'Enable auto-transparency',
          description: '启用自动透明度功能'
        },
        releaseTime: {
          visible: true,
          title: 'Release time',
          value: null,
          description: '配置释放时间'
        }
      },
      
      // 噪声识别
      noiseId: {
        visible: false, // 默认隐藏，根据设备支持情况显示
        title: 'Noise ID',
        state: {
          visible: true,
          enabled: false,
          title: 'Enable noise ID',
          description: '启用噪声识别功能'
        }
      },
      
      // 演示模式
      enterDemo: {
        visible: false, // 默认隐藏，根据设备支持情况显示
        title: 'Enter Demo',
        description: '进入音频管理演示模式'
      }
    },
    
    // 基础配置选项（与安卓版本ConfigurationOption.java保持一致）
    baseConfigurationOptions: {
      // Toggle基础选项（与安卓版本Configuration.java中的定义一致）
      toggle: {
        // 所有 toggle 共享相同的基础选项
        base: [
          { value: 0, label: 'Audio curation off' },           // TOGGLE_OFF
          { value: 255, label: 'Disable this toggle' }         // DISABLED
        ]
      },
      // 场景基础选项（与安卓版本Configuration.java中的定义一致）
      scenario: [
        { value: 0, label: 'Change to audio curation off' },   // CHANGE_TO_OFF
        { value: 255, label: 'Do not change current mode' }    // NO_CHANGE
      ]
    },
    
    // 释放时间选项（与安卓版本ReleaseTime.kt保持一致）
    releaseTimeOptions: [
      { value: 'NO_ACTION', label: 'No action on release' },
      { value: 'SHORT', label: 'Short' },
      { value: 'NORMAL', label: 'Normal' },
      { value: 'LONG', label: 'Long' }
    ],
    
    // 弹窗状态（与安卓版本保持一致）
    showDialog: false,
    dialogTitle: '',
    dialogOptions: [],
    dialogType: '',
    currentSetting: null,
    selectedOption: null,
    
    // 设备支持的功能版本
    supportedVersion: null,
    supportedModes: []
  },

  onLoad(options) {
    console.log('音频管理页面加载')
    // this.loadAudioCurationData()
  },

  onShow() {
    // 设置音频管理页面的 BLE 数据回调
    gaiaManager.setBleDataCallback((data) => {
      console.log('🎧 [音频管理] 接收到BLE数据:', data)
      this.handleBleData(data)
    })
    
    // 页面显示时刷新数据
    if (bluetoothManager.isConnected) {
      this.loadAudioCurationData()
    }
  },

  onHide() {
    // 清除音频管理页面的 BLE 数据回调，让其他页面可以设置回调
    gaiaManager.setBleDataCallback(null)
  },

  // 处理BLE数据回调
  handleBleData(data) {
    try {
      console.log('🎧 [音频管理] 处理BLE数据111111111111111111:', data)
      
      // 解析hexData
      const hexData = data.value
      const commandId = data.id
      const timestamp = data.timestamp
      
      console.log(`🎧 [音频管理] hexData: ${hexData}, commandId: ${commandId}, timestamp: ${timestamp}`)
      
      // 根据命令ID判断是否是ANC状态相关的数据
      if (commandId === 0x00) { // V1_GET_AC_STATE
        console.log('🎧 [音频管理] 接收到ANC状态响应数据:', hexData)
        this.handleANCStateResponse(hexData)
      } else if (commandId === 0x01) { // V1_SET_AC_STATE
        console.log('🎧 [音频管理] 接收到ANC状态设置响应数据:', hexData)
        this.handleANCStateSetResponse(hexData)
      } else {
        console.log('🎧 [音频管理] 接收到其他命令响应数据:', hexData, 'commandId:', commandId)
      }
      
    } catch (error) {
      console.error('🎧 [音频管理] 处理BLE数据失败:', error)
    }
  },

  // 处理ANC状态响应
  handleANCStateResponse(hexData) {
    try {
      console.log('🎧 [音频管理] 解析ANC状态响应:', hexData)
      
      // 解析GAIA响应格式: VENDOR_ID(2字节) + COMMAND_VALUE(2字节) + PAYLOAD
      if (hexData.length >= 8) { // 至少4字节头部 + 2字节payload
        const payloadHex = hexData.substring(8) // 跳过头部8个字符(4字节)
        const payload = this.hexToBytes(payloadHex)
        
        console.log('🎧 [音频管理] ANC状态payload:', payload)
        
        if (payload.length >= 2) {
          const feature = payload[0] // Feature.ANC = 0x01
          const state = payload[1]   // State: 0x00=禁用, 0x01=启用
          
          console.log(`🎧 [音频管理] Feature: 0x${feature.toString(16).padStart(2, '0')}, State: 0x${state.toString(16).padStart(2, '0')}`)
          
          const isEnabled = (state === 0x01)
          const isSupported = (feature === 0x01) // Feature.ANC
          
          // 更新页面数据
          this.setData({
            audioCurationSupported: isSupported,
            audioCurationState: state,
            'settings.ancState.enabled': isEnabled,
            'settings.ancState.supported': isSupported
          })
          
          // 显示状态信息
          if (isSupported) {
            const statusText = isEnabled ? '启用' : '禁用'
            console.log(`🎧 [音频管理] Active Noise Cancellation状态: ${statusText}`)
          } else {
            console.log('🎧 [音频管理] Active Noise Cancellation不支持')
          }
        } else {
          console.warn('🎧 [音频管理] ANC状态响应payload长度不足:', payload.length)
        }
      } else {
        console.warn('🎧 [音频管理] ANC状态响应数据长度不足:', hexData.length)
      }
      
    } catch (error) {
      console.error('🎧 [音频管理] 解析ANC状态响应失败:', error)
    }
  },

  // 处理ANC状态设置响应
  handleANCStateSetResponse(hexData) {
    try {
      console.log('🎧 [音频管理] 解析ANC状态设置响应:', hexData)
      
      // ANC状态设置响应通常是确认响应，payload为空或包含状态信息
      console.log('🎧 [音频管理] ANC状态设置完成')
      
    } catch (error) {
      console.error('🎧 [音频管理] 解析ANC状态设置响应失败:', error)
    }
  },

  // 将十六进制字符串转换为字节数组
  hexToBytes(hex) {
    const bytes = []
    for (let i = 0; i < hex.length; i += 2) {
      bytes.push(parseInt(hex.substr(i, 2), 16))
    }
    return bytes
  },

  // 加载ANC状态（与Android V3AudioCurationPlugin.fetchInfo(ACInfo.AC_FEATURE_STATE)一致）
  async loadAudioCurationFeatureState() {
    try {
      // 使用gaiaManager的getANCState方法获取ANC状态
       await gaiaManager.getANCState()
    } catch (error) {
      this.setData({
        audioCurationSupported: false,
        error: '获取ANC状态失败: ' + error.message
      })
    }
  },

  // 加载音频管理数据（与安卓版本AudioCurationViewModel.updateData()保持一致）
  async loadAudioCurationData() {
    
    if (!bluetoothManager.isConnected) {
      this.setData({
        loading: false,
        error: '设备未连接，请先连接设备'
      })
      return
    }

    this.setData({ loading: true, error: null })

    try {
      // 1. 获取音频管理功能状态（与Android V3AudioCurationPlugin.fetchInfo(ACInfo.AC_FEATURE_STATE)一致）
      await this.loadAudioCurationFeatureState()
      
      
      
      // 4. 获取各项配置
      // await this.loadAllConfigurations()
    } catch (error) {
      console.error('加载音频管理数据失败:', error)
      this.setData({
        error: '加载数据失败: ' + error.message
      })
    } finally {
      this.setData({ loading: false })
    }
  },

  // 更新设置项可见性（与安卓版本onAudioCurationSupported()一致）
  updateSettingsVisibility(version) {
    const settings = { ...this.data.settings }
    
    // 根据版本设置可见性（与安卓版本AudioCurationSettings.kt中的featureVersion一致）
    if (version >= 4) {
      settings.autoTransparency.visible = true
    }
    
    if (version >= 6) {
      settings.noiseId.visible = true
    }
    
    if (version >= 1) {
      settings.enterDemo.visible = true
    }
    
    if (version >= 3) {
      settings.otherConfigurations.items.find(item => item.key === 'voice_recording_configuration').visible = true
    }
    
    this.setData({ settings })
  },

  // 处理音频管理功能状态响应（与Android V3AudioCurationPlugin.publishState()一致）
  handleAudioCurationStateResponse(payload) {
    try {
      console.log('🎧 [音频管理功能状态] 开始解析音频管理功能状态响应:', payload)
      
      // 检查payload长度
      if (!payload || payload.length < 1) {
        return
      }

      // 解析状态（参考Android FeatureState解析逻辑）
      const state = payload[0]
      
      // 更新页面数据
      this.setData({
        audioCurationSupported: true,
        audioCurationState: state
      })
      
      
    } catch (error) {
    }
  },

  // 处理模式数量响应（与Android V3AudioCurationPlugin.publishModesCount()一致）
  handleModesCountResponse(payload) {
    try {
      
      if (!payload || payload.length < 1) {
        console.warn('🎧 [模式数量] payload为空或长度不足')
        return
      }

      const count = payload[0]
      
      // 更新页面数据
      this.setData({
        modesCount: count
      })
      
    } catch (error) {
      console.error('🎧 [模式数量] 解析模式数量失败:', error)
    }
  },

  // 处理当前模式响应（与Android V3AudioCurationPlugin.publishCurrentMode()一致）
  handleCurrentModeResponse(payload) {
    try {
      console.log('🎧 [当前模式] 开始解析当前模式响应:', payload)
      
      if (!payload || payload.length < 1) {
        console.warn('🎧 [当前模式] payload为空或长度不足')
        return
      }

      const mode = payload[0]
      console.log(`🎧 [当前模式] 当前模式: ${mode}`)
      
      // 更新页面数据
      this.setData({
        currentMode: mode
      })
      
    } catch (error) {
      console.error('🎧 [当前模式] 解析当前模式失败:', error)
    }
  },

  // 处理前馈增益响应（与Android V3AudioCurationPlugin.publishFeedForwardGain()一致）
  handleFeedForwardGainResponse(payload) {
    try {
      console.log('🎧 [前馈增益] 开始解析前馈增益响应:', payload)
      
      if (!payload || payload.length < 2) {
        console.warn('🎧 [前馈增益] payload长度不足')
        return
      }

      // 解析16位增益值
      const gain = (payload[1] << 8) | payload[0]
      console.log(`🎧 [前馈增益] 前馈增益: ${gain}`)
      
      // 更新页面数据
      this.setData({
        feedForwardGain: gain
      })
      
    } catch (error) {
      console.error('🎧 [前馈增益] 解析前馈增益失败:', error)
    }
  },

  // 处理切换配置数量响应（与Android V3AudioCurationPlugin.publishTogglesCount()一致）
  handleTogglesCountResponse(payload) {
    try {
      console.log('🎧 [切换配置数量] 开始解析切换配置数量响应:', payload)
      
      if (!payload || payload.length < 2) {
        console.warn('🎧 [切换配置数量] payload长度不足')
        return
      }

      const leftCount = payload[0]
      const rightCount = payload[1]
      console.log(`🎧 [切换配置数量] 左耳: ${leftCount}, 右耳: ${rightCount}`)
      
      // 更新页面数据
      this.setData({
        togglesCount: {
          left: leftCount,
          right: rightCount
        }
      })
      
    } catch (error) {
      console.error('🎧 [切换配置数量] 解析切换配置数量失败:', error)
    }
  },

  // 处理切换配置响应（与Android V3AudioCurationPlugin.publishToggleConfiguration()一致）
  handleToggleConfigurationResponse(payload) {
    try {
      console.log('🎧 [切换配置] 开始解析切换配置响应:', payload)
      
      if (!payload || payload.length < 1) {
        console.warn('🎧 [切换配置] payload为空或长度不足')
        return
      }

      const configuration = payload[0]
      console.log(`🎧 [切换配置] 切换配置: ${configuration}`)
      
      // 更新页面数据
      this.setData({
        toggleConfiguration: configuration
      })
      
    } catch (error) {
      console.error('🎧 [切换配置] 解析切换配置失败:', error)
    }
  },

  // 加载所有配置（与安卓版本updateData()一致）
  async loadAllConfigurations() {
    try {
      // 1. 获取ANC状态（与安卓版本onState()一致）
      const ancResponse = await gaiaManager.getANCState()
      if (ancResponse.success) {
        this.setData({ 
          'settings.ancState.enabled': ancResponse.data.enabled
        })
      }

      // 2. 获取自动透明度状态（与安卓版本onAutoTransparencyState()一致）
      const autoTransparencyResponse = await gaiaManager.getAutoTransparencyState()
      if (autoTransparencyResponse.success) {
        this.setData({ 
          'settings.autoTransparency.state.enabled': autoTransparencyResponse.data.enabled
        })
      }

      // 3. 获取噪声识别状态（与安卓版本onNoiseIdState()一致）
      const noiseIdResponse = await gaiaManager.getNoiseIdState()
      if (noiseIdResponse.success) {
        this.setData({
          'settings.noiseId.state.enabled': noiseIdResponse.data.enabled
        })
      }

      // 4. 获取释放时间（与安卓版本onAutoTransparencyReleaseTime()一致）
      const releaseTimeResponse = await gaiaManager.getAutoTransparencyReleaseTime()
      if (releaseTimeResponse.success) {
        const time = releaseTimeResponse.data.time
        const option = this.data.releaseTimeOptions.find(opt => opt.value === time)
        if (option) {
          this.setData({
            'settings.autoTransparency.releaseTime.value': option.label
          })
        }
      }

      // 5. 获取场景配置（与安卓版本onScenarioConfiguration()一致）
      await this.loadScenarioConfigurations()

    } catch (error) {
      console.error('加载配置失败:', error)
    }
  },

  // 加载切换配置（与安卓版本onToggleConfiguration()一致）
  async loadToggleConfiguration(toggle) {
    try {
      const response = await gaiaManager.getToggleConfiguration(toggle)
      if (response.success) {
        const value = response.data.value
        // 生成完整的配置选项（基础选项 + 模式选项）
        const fullOptions = this.generateToggleOptions(toggle)
        const option = fullOptions.find(opt => opt.value === value)
        if (option) {
          this.setData({
            [`settings.toggleConfiguration.items[${toggle - 1}].value`]: option.label
          })
        }
      }
    } catch (error) {
      console.error(`加载切换${toggle}配置失败:`, error)
    }
  },

  // 加载场景配置（与安卓版本onScenarioConfiguration()一致）
  async loadScenarioConfigurations() {
    try {
      const settings = { ...this.data.settings }
      const scenarios = [
        { key: 'idle_configuration', value: 0 },
        { key: 'playback_configuration', value: 1 },
        { key: 'calls_configuration', value: 2 },
        { key: 'assistant_configuration', value: 3 },
        { key: 'voice_recording_configuration', value: 4 }
      ]

      for (const scenario of scenarios) {
        const response = await gaiaManager.getScenarioConfiguration(scenario.value)
        if (response.success) {
          const value = response.data.value
          // 生成完整的配置选项（基础选项 + 模式选项）
          const fullOptions = this.generateScenarioOptions()
          const option = fullOptions.find(opt => opt.value === value)
          if (option) {
            const item = settings.otherConfigurations.items.find(item => item.key === scenario.key)
            if (item) {
              item.value = option.label
            }
          }
        }
      }
      
      this.setData({ settings })
    } catch (error) {
      console.error('加载场景配置失败:', error)
    }
  },

  // 生成Toggle配置选项（与安卓版本getConfigurationEntries()一致）
  generateToggleOptions(toggle) {
    // 获取基础选项（所有 toggle 共享）
    const baseOptions = this.data.baseConfigurationOptions.toggle.base || []
    
    // 生成模式选项（与安卓版本audio_curation_mode_label一致）
    const modeOptions = this.data.supportedModes.map(mode => ({
      value: mode.value,
      label: `Mode ${mode.value}` // 与 Android 弹窗显示一致
    }))
    
    // 合并基础选项和模式选项
    return [...baseOptions, ...modeOptions]
  },

  // 生成场景配置选项（与安卓版本getConfigurationEntries()一致）
  generateScenarioOptions() {
    const baseOptions = this.data.baseConfigurationOptions.scenario
    const modeOptions = this.data.supportedModes.map(mode => ({
      value: mode.value,
      label: `Change to mode ${mode.value}` // 与安卓版本settings_audio_curation_option_change_to_mode一致
    }))
    
    return [...baseOptions, ...modeOptions]
  },

  // ANC状态改变（与安卓版本setState()一致）
  async onAncStateChange(e) {
    // 防止重复点击
    if (this.data.ancChanging) {
      console.log('ANC状态正在改变中，忽略重复点击')
      return
    }
    
    // 与Android版本一致：AudioCurationSettingsFragment.onPreferenceChange()
    // if (AudioCurationSettings.ANC_STATE.equals(key) && update instanceof Boolean) {
    //     getViewModel().setState(Feature.ANC, (boolean) update);
    //     return false; // view model will update the state depending on request result
    // }
    
    const enabled = Boolean(e.detail.value)  // 确保是布尔值，与Android版本一致
    console.log('ANC状态改变:', enabled, '原始值:', e.detail.value)
    
    // 设置状态改变中标志
    this.setData({
      ancChanging: true
    })
    
    // 与Android版本一致：先不更新UI状态，等待GAIA命令结果
    // Android: return false; // view model will update the state depending on request result
    
    try {
      await gaiaManager.setANCState(enabled)
      this.setData({
        'settings.ancState.enabled': enabled,
        ancChanging: false  // 重置状态改变标志
      })
      wx.showToast({
        title: enabled ? 'ANC已启用' : 'ANC已禁用',
        icon: 'success',
        duration: 1000
      })
    } catch (error) {
      console.error('设置ANC状态失败:', error)
      // 异常情况，回滚UI状态（与Android版本一致）
      this.setData({
        'settings.ancState.enabled': !enabled,  // 回滚到之前的状态
        ancChanging: false  // 重置状态改变标志
      })
      wx.showToast({
        title: '设置失败',
        icon: 'error',
        duration: 2000
      })
    }
  },

  // 自动透明度状态改变（与安卓版本setAutoTransparencyState()一致）
  async onAutoTransparencyChange(e) {
    const enabled = e.detail.value
    console.log('自动透明度状态改变:', enabled)
    
    try {
      const response = await gaiaManager.setAutoTransparencyState(enabled)
      if (response.success) {
        this.setData({
          'settings.autoTransparency.state.enabled': enabled
        })
        wx.showToast({
          title: enabled ? '自动透明度已启用' : '自动透明度已禁用',
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '设置失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('设置自动透明度状态失败:', error)
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      })
    }
  },

  // 噪声识别状态改变（与安卓版本setNoiseIdState()一致）
  async onNoiseIdChange(e) {
    const enabled = e.detail.value
    console.log('噪声识别状态改变:', enabled)
    
    try {
      const response = await gaiaManager.setNoiseIdState(enabled)
      if (response.success) {
        this.setData({
          'settings.noiseId.state.enabled': enabled
        })
        wx.showToast({
          title: enabled ? '噪声识别已启用' : '噪声识别已禁用',
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '设置失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('设置噪声识别状态失败:', error)
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      })
    }
  },

  // 显示配置选择弹窗（与安卓版本onPreferenceChange()一致）
  showConfigurationPicker(e) {
    const { type, key, title } = e.currentTarget.dataset
    
    let options = []
    let currentValue = null
    let dialogTitle = title
    
    if (type === 'toggle') {
      // 根据切换类型生成完整的选项（与安卓版本getConfigurationEntries()一致）
      const toggleNumber = parseInt(key.split('_')[1])
      options = this.generateToggleOptions(toggleNumber).map(option => ({
        ...option,
        selected: false
      }))
      
      // 设置弹窗标题为具体的 Toggle 编号（与 Android 一致）
      dialogTitle = `Toggle ${toggleNumber}`
      
      // 设置当前选中值
      const currentItem = this.data.settings.toggleConfiguration.items.find(item => item.key === key)
      if (currentItem && currentItem.value) {
        const selectedOption = options.find(opt => opt.label === currentItem.value)
        if (selectedOption) {
          selectedOption.selected = true
          currentValue = selectedOption
        }
      }
    } else if (type === 'scenario') {
      // 生成场景配置选项（与安卓版本getConfigurationEntries()一致）
      options = this.generateScenarioOptions().map(option => ({
        ...option,
        selected: false
      }))
      
      // 设置当前选中值
      const currentItem = this.data.settings.otherConfigurations.items.find(item => item.key === key)
      if (currentItem && currentItem.value) {
        const selectedOption = options.find(opt => opt.label === currentItem.value)
        if (selectedOption) {
          selectedOption.selected = true
          currentValue = selectedOption
        }
      }
    } else if (type === 'releaseTime') {
      options = this.data.releaseTimeOptions.map(option => ({
        ...option,
        selected: false
      }))
      
      // 设置当前选中值
      const currentValue = this.data.settings.autoTransparency.releaseTime.value
      if (currentValue) {
        const selectedOption = options.find(opt => opt.label === currentValue)
        if (selectedOption) {
          selectedOption.selected = true
        }
      }
    }
    
    this.setData({
      showDialog: true,
      dialogTitle: dialogTitle,
      dialogOptions: options,
      dialogType: type,
      currentSetting: key,
      selectedOption: currentValue
    })
  },

  // 选择弹窗选项（与 Android 一致，选择后立即应用）
  onOptionSelect(e) {
    const { value, index } = e.currentTarget.dataset
    
    // 更新选中状态
    const dialogOptions = this.data.dialogOptions.map((option, i) => ({
      ...option,
      selected: i === index
    }))
    
    const selectedOption = dialogOptions[index]
    
    // 立即应用选择（与 Android 行为一致）
    this.applyConfigurationChange(selectedOption)
    
    // 关闭弹窗
    this.setData({
      showDialog: false,
      dialogTitle: '',
      dialogOptions: [],
      dialogType: '',
      currentSetting: null,
      selectedOption: null
    })
  },

  // 应用配置更改（与 Android 行为一致）
  async applyConfigurationChange(selectedOption) {
    try {
      if (this.data.dialogType === 'toggle') {
        await this.updateToggleConfiguration(this.data.currentSetting, selectedOption.value, selectedOption)
      } else if (this.data.dialogType === 'scenario') {
        await this.updateScenarioConfiguration(this.data.currentSetting, selectedOption.value, selectedOption)
      } else if (this.data.dialogType === 'releaseTime') {
        await this.updateReleaseTime(selectedOption.value, selectedOption)
      }
    } catch (error) {
      console.error('应用配置更改失败:', error)
      wx.showToast({ title: '设置失败', icon: 'error' })
    }
  },

  // 确认弹窗选择（与安卓版本onPreferenceChange()一致）
  async onDialogConfirm() {
    if (!this.data.selectedOption) {
      wx.showToast({
        title: '请选择一个选项',
        icon: 'none'
      })
      return
    }

    try {
      if (this.data.dialogType === 'toggle') {
        await this.updateToggleConfiguration(this.data.currentSetting, this.data.selectedOption.value)
      } else if (this.data.dialogType === 'scenario') {
        await this.updateScenarioConfiguration(this.data.currentSetting, this.data.selectedOption.value)
      } else if (this.data.dialogType === 'releaseTime') {
        await this.updateReleaseTime(this.data.selectedOption.value)
      }

      // 关闭弹窗
      this.setData({
        showDialog: false,
        dialogTitle: '',
        dialogOptions: [],
        dialogType: '',
        currentSetting: null,
        selectedOption: null
      })

      wx.showToast({
        title: '配置已更新',
        icon: 'success'
      })
    } catch (error) {
      console.error('更新配置失败:', error)
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      })
    }
  },

  // 取消弹窗
  onDialogCancel() {
    this.setData({
      showDialog: false,
      dialogTitle: '',
      dialogOptions: [],
      dialogType: '',
      currentSetting: null,
      selectedOption: null
    })
  },

  // 防止点击弹窗内容时关闭弹窗
  onDialogContainerTap() {
    // 阻止事件冒泡
  },

  // 更新切换配置（与安卓版本setToggleConfiguration()一致）
  async updateToggleConfiguration(key, value, selectedOption) {
    const toggleMap = {
      'toggle_1': 1,
      'toggle_2': 2,
      'toggle_3': 3
    }
    
    const toggle = toggleMap[key]
    if (toggle) {
      // await gaiaManager.setToggleConfiguration(toggle, value)
      
      // 更新显示
      const settings = { ...this.data.settings }
      const item = settings.toggleConfiguration.items.find(item => item.key === key)
      if (item && selectedOption) {
        item.value = selectedOption.label
      }
      this.setData({ settings })
    }
  },

  // 更新场景配置（与安卓版本setScenarioConfiguration()一致）
  async updateScenarioConfiguration(key, value, selectedOption) {
    const scenarioMap = {
      'idle_configuration': 0,
      'playback_configuration': 1,
      'calls_configuration': 2,
      'assistant_configuration': 3,
      'voice_recording_configuration': 4
    }
    
    const scenario = scenarioMap[key]
    if (scenario !== undefined) {
      // await gaiaManager.setScenarioConfiguration(scenario, value)
      
      // 更新显示
      const settings = { ...this.data.settings }
      const item = settings.otherConfigurations.items.find(item => item.key === key)
      if (item && selectedOption) {
        item.value = selectedOption.label
      }
      this.setData({ settings })
    }
  },

  // 更新释放时间（与安卓版本setAutoTransparencyReleaseTime()一致）
  async updateReleaseTime(value, selectedOption) {
    await gaiaManager.setAutoTransparencyReleaseTime(value)
    
    // 更新显示
    if (selectedOption) {
      this.setData({
        'settings.autoTransparency.releaseTime.value': selectedOption.label
      })
    }
  },

  // 进入演示模式（与安卓版本onPreferenceTreeClick()一致）
  enterDemo() {
    wx.navigateTo({
      url: '/pages/audiocuration-demo/audiocuration-demo'
    })
  },

  // 重试加载
  retryLoad() {
    this.loadAudioCurationData()
  }
})


